package com.ejlchina.keno

import kotlinx.coroutines.delay
import kotlin.random.Random

/*
 平铺列表，然后计算每个数字出现的数量
 */
fun getAppearCount(sourceList: List<List<Int>>): Map<Int, Int>{
    return sourceList.flatten().groupBy { it }
        .mapValues { (_, items) -> items.count() }
        .toList().sortedByDescending { (_, value) -> value }.toMap()
}

/*
 平铺列表，然后计算每个数字出现的数量
 */
fun getAppearCountIntList(sourceList: List<Int>): Map<Int, Int>{
    return sourceList.groupBy { it }
        .mapValues { (_, items) -> items.count() }
        .toList().sortedByDescending { (_, value) -> value }.toMap()
}

/*
 不平铺列表，然后计算每个item出现的数量
 */
fun getAppearListCount(sourceList: List<List<Int>>): Map<List<Int>, Int>{
    return sourceList.groupBy { it }.mapValues { (_, items) -> items.count() }
        .toList().sortedByDescending { (_, value) -> value }.toMap()
}

fun getSameCountBetweenTwoList(list1: List<Int>, list2: List<Int>) :Int {
    val set2 = list2.toSet()
    return list1.count { item -> item in set2 }
}

/**
 * 在0到until(不包含)这些数字中，随机生成count个数字
 */
fun getRandomNumber(until: Int,count: Int): List<Int> {
    val list = (0 until until).toMutableList()
    // 用于存储随机选取的until个数字
    val randomNumbers = mutableListOf<Int>()
    // 随机选取count个不重复的数字
    repeat(count) {
        // 生成一个随机索引
        val randomIndex = Random.nextInt(list.size)
        // 从列表中取出对应索引的数字
        val number = list.removeAt(randomIndex)
        // 将选取的数字添加到结果列表中
        randomNumbers.add(number)
    }
    return randomNumbers
}

/**
 * 求两个Int类型的List的重复元素的个数
 */
fun countCommonElements(list1: List<Int>, list2: List<Int>): Int {
    // 将列表转换为集合，并求交集
    val commonElements = list1.toSet().intersect(list2.toSet())
    // 返回交集的大小
    return commonElements.size
}

/**
 * 多个Int类型的List的交集
 */
fun intersectManyList(vararg lists: List<Int>): List<Int> {
    // 如果传入的列表为空，直接返回空列表
    if (lists.isEmpty()) return emptyList()

    // 使用第一个列表作为基准
    var result = lists[0].toSet()

    // 遍历剩余的列表，逐步取交集
    for (list in lists.drop(1)) {
        result = result.intersect(list.toSet())
    }

    // 将结果转换为List并排序
    return result.toList().sorted()
}

/**
 * Int类型的List的交集
 */
fun intersectManyList(lists: List<List<Int>>): List<Int> {
    // 如果传入的列表为空，直接返回空列表
    if (lists.isEmpty()) return emptyList()

    // 使用第一个列表作为基准
    var result = lists[0].toSet()

    // 遍历剩余的列表，逐步取交集
    for (list in lists.drop(1)) {
        result = result.intersect(list.toSet())
    }

    // 将结果转换为List并排序
    return result.toList().sorted()
}

fun unionManyList(vararg lists: List<Int>): List<Int> {
    return lists.flatMap { it }.toSet().sorted()
}

fun unionManyList(lists: List<List<Int>>): List<Int> {
    return lists.flatten().toSet().sorted()
}

suspend fun getRandomIntFrom1T35(endCount: Int): List<Int> {
    val randomList = mutableListOf<Int>()
    while (randomList.size < endCount) {
        delay(Random.nextInt(1,10).toLong())
        val randomInt = Random.nextInt(1,36)
        if (!randomList.contains(randomInt)) {
            randomList.add(randomInt)
        }
    }
    return randomList.sorted()
}

suspend fun getRandomIntFrom1T12(endCount: Int, noInt: List<Int>): List<Int> {
    val randomList = mutableListOf<Int>()
    while (randomList.size < endCount) {
        delay(Random.nextInt(1,10).toLong())
        val randomInt = Random.nextInt(1,13)
        if (!randomList.contains(randomInt) && !noInt.contains(randomInt)) {
            randomList.add(randomInt)
        }
    }
    return randomList.sorted()
}

fun getPageLineIndexFromSampleIndex(sampleIndex: Int): Pair<Int, Int> {
    val offsetSampleIndex = sampleIndex + 1
    return when(offsetSampleIndex / 5) {
        0 ->{
            Pair(1,offsetSampleIndex % 5)
        }
        else -> {
            when(offsetSampleIndex % 5) {
                0 -> {
                    Pair(offsetSampleIndex / 5,5)
                }
                else -> {
                    Pair((offsetSampleIndex / 5) + 1, offsetSampleIndex % 5)
                }
            }
        }
    }
}